1. Field of the Invention
The present invention is directed to systems and techniques for designing programmable processing elements such as microprocessors and the like. More particularly, the invention is directed to the design of an application solution containing one or more processors where the processors in the system are configured and enhanced at the time of their design to improve their suitability to a particular application.
2. Background of the Related Art
U.S. Pat. No. 6,477,683 to Killian et al. (incorporated by reference) describes a system for designing microprocessors and corresponding software systems tailored for a particular application. Prior to that system, users developed programs on processors designed for running a large variety of computer programs. Because the same processor had to function well for a variety of applications, the processor would not be ideally suited for any individual application. The Killian et al. invention allows the user to tailor the microprocessor for the user""s particular application and provides a core processor coupled with a graphical user interface to allow the user to easily configure his particular processor. Via a check-box menu, the user can choose to include or leave out many hardware features such as hardware multipliers, debug registers, register windows and the like. Via a menu, the user can select the sizes and characteristics of many hardware features such as the size of the cache, the number of physical registers and the like. For further configurability, the user may add user-designed instructions to the processors. The user describes the instructions using a high level hardware description language, and the system manages the integration of the instruction with the rest of the processor and creates a software system to allow programmers to use the instructions in their applications.
Once the user selects a processor configuration via the GUI, the system creates a hardware description of the configured processor as well as a software system tailored to the designed hardware. The joint hardware-software system can be built, i.e., its full hardware and software description completely developed, at the user""s site using tools provided by the system vendor or can be built at the vendor""s site and delivered to the customer via the Internet or some other appropriate data communications network. In either case, once the user has selected her processor configuration, the hardware and software for that configuration can be delivered in a few hours.
The above system gives the user flexibility to design a processor well-suited for her application, but is cumbersome for interactive development of hardware and software. To more fully understand this problem, consider a typical approach used by many software designers to tune the performance of their software application. They will typically think of a potential improvement, modify their software to use that potential improvement, recompile their software source to generate a runnable application containing that potential improvement and then evaluate the potential improvement. Depending on the results of that evaluation, they might keep or discard the potential improvement. Typically, the entire process can be completed in only a few minutes. This allows the user to experiment freely, quickly trying out and keeping or discarding ideas. In some cases, just evaluating a potential idea is complicated. The user might want to test the idea in a large variety of situations. In such cases, the user often keeps multiple versions of the compiled application: one original version and another version containing the potential improvement. In some cases, potential improvements might interact, and the user might keep more than two copies of the application, each using a different subset of the potential improvements. By keeping multiple versions, the user can easily test the different versions repeatedly under different circumstances.
Users of configurable processors would like to interactively develop hardware and software jointly in a similar fashion to the way that software developers develop software on traditional processors. Consider the case of users adding custom instructions to a configurable processor. Users would like to interactively add potential instructions to their processor and test and evaluate those instructions on their particular application. With prior art systems, including the Killian et al. system, this is difficult for three reasons.
First, after proposing a potential instruction, the user must wait an hour or more before obtaining a compiler and simulator that can take advantage of the instruction.
Second, when the user wishes to experiment with many potential instructions, the user must create and keep a software development system for each. The software development system can be very large. Keeping many versions can become unmanageable.
Finally, the software development system is configured for the entire processor. That makes it difficult to separate the development process among different engineers. Consider an example where two developers are working on a particular application. One developer might be responsible for deciding on cache characteristics of the processor and another responsible for adding customized instructions. While the work of the two developers is related, each piece is sufficiently separable so that each developer can work on her task in isolation. The cache developer might initially propose a particular configuration. The other developer starts with that configuration and tries out several instructions, building a software development system for each potential instruction. Now, the cache developer modifies the proposed cache configuration. The other developer must now rebuild every one of her configurations, since each of her configurations assumed the original cache configuration. With many developers working on a project, organizing the different configurations can quickly become unmanageable.
The present invention has been developed with the above problems of the prior art in mind, and an object of the present invention is to allow the user to customize a processor configuration by adding new instructions and within minutes, be able to evaluate that feature. The user is able to keep multiple sets of potential instructions or state (hereinafter the combination of potential configurable instructions or state will be referred to collectively as xe2x80x9cprocessor enhancementsxe2x80x9d) and easily switch between them when evaluating their application.
The user selects and builds a base processor configuration using the methods described in the Killian et al. application. The user creates a new set of user-defined processor enhancements and places them in a file directory. The user then invokes a tool that processes the user enhancements and transforms them into a form usable by the base software development tools. This transformation is very quick since it involves only the user-defined enhancements and does not build an entire software system. The user then invokes the base software development tools, telling the tools to dynamically use the processor enhancements created in the new directory. Preferably, the location of the directory is given to the tools either via a command line option or via an environment variable. To further simplify the process, the user can use standard software makefiles. These enable the user to modify their processor instructions and then via a single make command, process the enhancements and use the base software development system to rebuild and evaluate their application in the context of the new processor enhancements.
The invention overcomes the three limitations of the prior art approach. Given a new set of potential enhancements, the user can evaluate the new enhancements in a matter of minutes. The user can keep many versions of potential enhancements by creating new directories for each set. Since the directory only contains descriptions of the new enhancements and not the entire software system, the storage space required is minimal. Finally, the new enhancements are decoupled from the rest of the configuration. Once the user has created a directory with a potential set of new enhancements, she can use that directory with any base configuration.